home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 013 / chkdir.arc / CHKDIR.MAC < prev   
Encoding:
Text File  |  1985-03-29  |  11.9 KB  |  362 lines
  1. $define(tag,$$segment(@1,$$index(@1,=)+1))#
  2. /*  CHKDIR - Report on directory status.
  3.  
  4.     BY:  Thom Henderson
  5.  
  6.     DESCRIPTION:
  7.      Prints a report similar to that produced by CHKDSK, but
  8.      pertaining to the current or named directory. Disk allocation
  9.      errors are NOT (repeat, NOT) fixed.
  10.  
  11.     INSTRUCTIONS:
  12.      Invoke this program with a statement of the form:
  13.  
  14.           CHKDIR [d:][path]
  15.  
  16.     LANGUAGE:
  17.      Computer Innovations C86
  18.  
  19.     SPECIAL NOTES:
  20.      This program should be compiled and linked
  21.      using the "small model".
  22. */
  23. #include <stdio.h>
  24.  
  25. struct fds                   /* file data structure */
  26. {   char dummy[21];               /* reserved for dos */
  27.     unsigned char att;               /* returned attribute */
  28.     unsigned time;
  29.     unsigned date;
  30.     long size;                   /* size of file */
  31.     unsigned char name[13];           /* string containing the filename */
  32.     int first;                   /* true during first search */
  33. };
  34.  
  35. char srchname[200] = 0;            /* search template */
  36. long room;                   /* total room on disk */
  37. long roomleft;                   /* room left on disk */
  38.  
  39. /*  file grouping parameters:
  40.  
  41.     files are grouped in the following categories:
  42.  
  43.     0     anything in a subdirectory
  44.     1     all files of whatever kind
  45.     2     all user files
  46.     3     all read only user files
  47.     4     all hidden or system files
  48.     5     all normal subdirectories
  49.     6     all hidden or system subdirectories
  50.  
  51.     Each group contains the following parts:
  52.  
  53.     0     everything
  54.     1     everything not backed up
  55.     2     everything backed up
  56. */
  57.  
  58. #define ngrps 7                /* number of file groups */
  59.  
  60. long size[ngrps][3] = 0;           /* bytes in each group */
  61. int num[ngrps][3] = 0;               /* files in each group */
  62.  
  63. /* option flags */
  64.  
  65. int subsrch = 0;               /* true if looking in subdirs */
  66. int subsep = 1;                /* true if subdir files not added */
  67. int reptype = 0;               /* which part to report */
  68.  
  69. main(an,arg)                   /* report on directory status */
  70. int an;                    /* number of arguments */
  71. char *arg[];                   /* pointers to same */
  72. {
  73.     int a;                   /* argument index */
  74.     char *ap;                   /* argument pointer */
  75.  
  76.     for(a=1; a<an; a++)            /* scan each arg */
  77.     {     ap = arg[a];               /* get a pointer to it */
  78.  
  79.          if(*ap=='-' || *ap=='/')      /* if an option marker */
  80.      {    while(*++ap)           /* then scan the marks */
  81.           {    switch(tolower(*ap))/* and act on them */
  82.            {
  83.                    case 'a':
  84.             subsep = 0;
  85.                    case 's':
  86.             subsrch = 1;
  87.             break;
  88.                    case 'c':
  89.             reptype = 1;
  90.             break;
  91.                    case 'b':
  92.             reptype = 2;
  93.             break;
  94.            default:
  95.             usage();
  96.            }
  97.           }
  98.      }
  99.      else                   /* else assume it is a path */
  100.      {    if(*srchname)           /* watch out for multiples */
  101.            usage();
  102.           strcpy(srchname,ap);     /* store name in search template */
  103.      }
  104.     }
  105.  
  106.     collect();                   /* collect the data */
  107.     volume();                   /* report on volume */
  108.     disk();                   /* report on disk */
  109.     memory();                   /* report on memory */
  110.  
  111.     return 0;                   /* no error we know of */
  112. }
  113.  
  114. usage()                    /* an error in usage */
  115. {   printf("CHKDIR, Version $tag(
  116. TED_VERSION DB =1.43), created on $tag(
  117. TED_DATE DB =10/17/84) at $tag(
  118. TED_TIME DB =10:31:29)\n");
  119.     printf("(C)COPYRIGHT 1984 by System Enhancement Associates; may be\n");
  120.     printf("    freely distributed in its original, unmodified form.\n\n");
  121.     printf("If you like this program and find it useful,\n");
  122.     printf("please send five dollars to:\n\n");
  123.     printf("   System Enhancement Associates\n");
  124.     printf("   12 Franklin Avenue\n");
  125.     printf("   Clifton, NJ  07011\n");
  126.     printf("   (201) 694-4710\n\n");
  127.     printf("usage: chkdir [-sacb] [d:][path]\n");
  128.     printf("          -s = search subdirectories\n");
  129.     printf("          -a = add subdirectory files to report\n");
  130.     printf("          -c = report only on files not backed up\n");
  131.     printf("          -b = report only on files backed up\n");
  132.     printf("          -h = print this list\n");
  133.     exit(1);
  134. }
  135.  
  136. volume()                   /* report on volume */
  137. {
  138.     struct fds vd;               /* volume data structure */
  139.  
  140.     if(volname(&vd))               /* if we have a volume */
  141.     {     printf("Volume %s, created ",vd.name);
  142.      pdate(vd.date); ptime(vd.time);
  143.      printf("\n");
  144.     }
  145. }
  146.  
  147. disk()                       /* report on disk */
  148. {
  149.     static char *type[] =           /* report types */
  150.     {     "all files",
  151.      "files which are not backed up",
  152.      "files which have been backed up"
  153.     };
  154.     static char *name[] =           /* group names */
  155.     {     "files in subdirectories",
  156.      "files",
  157.      "user files",
  158.      "read only user files",
  159.      "hidden or system files",
  160.      "subdirectories",
  161.      "hidden or system subdirectories"
  162.     };
  163.     int g;                   /* group index */
  164.     char *dir;                   /* pointer to directory name */
  165.     char *gcdir();               /* gets name of current directory */
  166.  
  167.     dir = *srchname ? srchname : gcdir("");
  168.     printf("Report on %s for %s\n\n",type[reptype],dir);
  169.  
  170.     printf("%9ld bytes total disk space\n",room);
  171.     if(num[0][reptype])
  172.      printf("%9ld bytes in %d files in %d directories\n",
  173.           size[0][reptype],num[0][reptype],num[5][0]);
  174.     for(g=1; g<ngrps; g++)
  175.      if(num[g][reptype])
  176.           printf("%9ld bytes in %d %s\n",
  177.            size[g][reptype],num[g][reptype],name[g]);
  178.     printf("%9ld bytes available on disk\n\n",roomleft);
  179. }
  180.  
  181. collect()                   /* collect our data */
  182. {
  183.     struct {int ax,bx,cx,dx,si,di,ds,es;} reg;
  184.  
  185.     reg.ax = (0x36 << 8);           /* get disk free space */
  186.     if(srchname[1]==':')               /* if path includes a drive */
  187.          reg.dx = tolower(srchname[0])-'a'+1;
  188.     else reg.dx = 0;               /* else default drive */
  189.     sysint21(®,®);           /* DOS call */
  190.  
  191.     if(reg.ax==0xffff)
  192.      abort("%c: is an invalid drive",srchname[0]);
  193.  
  194.     room = (long)reg.dx * (long)reg.cx * (long)reg.ax;
  195.     roomleft = (long)reg.bx * (long)reg.cx * (long)reg.ax;
  196.  
  197.     fcollect(srchname,0);           /* collect the file data */
  198. }
  199.  
  200. fcollect(path,sub)               /* collect data on directory */
  201. char *path;                   /* name of directory */
  202. int sub;                   /* true if in a subdirectory */
  203. {
  204.     char pbuf[200];               /* modified path buffer */
  205.     char sbuf[200];               /* subdirectory path buffer */
  206.     struct fds fd;               /* file data structure */
  207.     int g;                   /* group index */
  208.     char *makepath();               /* path name fixer */
  209.  
  210.     makepath(pbuf,path,"*.*");           /* make a search template */
  211.     fd.first = 1;               /* note start of a search */
  212.  
  213.     while(filedir(&fd,pbuf))           /* while we have files */
  214.     {     if(fd.att&0x10)           /* if a subdirectory */
  215.          {    if(*fd.name=='.')        /* if a phony directory */
  216.            continue;           /* then do not add it in */
  217.           if(subsrch)           /* if we are searching subs */
  218.            fcollect(makepath(sbuf,path,fd.name),subsep);
  219.      }
  220.  
  221.      if(sub)               /* if in a subdirectory */
  222.           addfile(&fd,0);           /* then add to subdir file group */
  223.      else                   /* else add in wherever needed */
  224.      {    addfile(&fd,1);           /* add to total */
  225.  
  226.           if(fd.att&0x10)           /* subdirectory */
  227.           {    if(fd.att&0x06)     /* hidden or system */
  228.             addfile(&fd,6);
  229.            else addfile(&fd,5);
  230.           }
  231.  
  232.           else if(fd.att&0x06)     /* hidden or system file */
  233.            addfile(&fd,4);
  234.  
  235.           else if(fd.att&0x01)     /* read only file */
  236.            addfile(&fd,3);
  237.  
  238.           else addfile(&fd,2);     /* else normal user file */
  239.      }
  240.     }
  241. }
  242.  
  243. char *makepath(buf,path,add)           /* make a path name or template */
  244. char *buf;                   /* storage for result */
  245. char *path;                   /* starting path name */
  246. char *add;                   /* text to add on the end */
  247. {
  248.     extern char *makefnam();           /* filename fixer (optional) */
  249.     char *b = buf;               /* string copy pointer */
  250.     char c = 0;                /* one char of copy */
  251.  
  252.     while(*path)               /* copy over the path */
  253.      *b++ = c = *path++;
  254.  
  255.     if(c)                   /* if any path at all */
  256.          if(c!='\\' && c!=':')         /* if not path and not just disk */
  257.               *b++ = '\\';             /* then add a backslash */
  258.  
  259.     while(*b++ = *add++);           /* tack on the added part */
  260.     return makefnam(buf,"",buf);       /* pass back fixed up name */
  261. }
  262.  
  263. addfile(fd,grp)                /* add a file to a group */
  264. struct fds *fd;                /* pointer to file data */
  265. int grp;                   /* group to add file to */
  266. {
  267.     num[grp][0] += 1;               /* add to total */
  268.     size[grp][0] += fd->size;
  269.     if(fd->att&0x20)               /* if file is not backed up */
  270.     {     num[grp][1] += 1;           /* then add to changed total */
  271.      size[grp][1] += fd->size;
  272.     }
  273.     else                   /* else add to backed up total */
  274.     {     num[grp][2] += 1;
  275.      size[grp][2] += fd->size;
  276.     }
  277. }
  278.  
  279. memory()                   /* report on memory */
  280. {
  281.     struct {int scs,sss,sds,ses;} seg;
  282.     struct {int ax,bx,cx,dx,si,di,ds,es;} reg;
  283.     long core;                   /* total system memory */
  284.     long coreused;               /* system memory in use */
  285.  
  286.     segread(&seg);               /* read our segment registers */
  287.     coreused = (long)seg.scs * 16;     /* see how much is in use */
  288.     sysint(0x12,®,®);           /* memory size determination */
  289.     core = (long)reg.ax * 1024;        /* set total system memory */
  290.  
  291.     printf("%9ld bytes total memory\n",core);
  292.     printf("%9ld bytes in use\n",coreused);
  293.     printf("%9ld bytes free\n",core-coreused);
  294. }
  295.  
  296. int filedir(fd,name)               /* get a directory entry */
  297. struct fds *fd;                /* data storage area */
  298. char *name;                   /* filename template */
  299. {
  300.     struct {int ax,bx,cx,dx,si,di,ds,es;} reg;
  301.  
  302.     segread(®.si);               /* set the segments */
  303.     bdos(0x1a,fd);               /* set the transfer address */
  304.  
  305.     reg.dx = name;               /* point to search template */
  306.     reg.cx = 0x16;               /* include special files */
  307.     if(fd->first)               /* if this is our first call */
  308.      reg.ax = (0x4e << 8);           /* then find first */
  309.     else reg.ax = (0x4f << 8);           /* else find next */
  310.     fd->first = 0;               /* next will not be first */
  311.     return !(sysint21(®,®)&1);   /* return true if it works */
  312. }
  313.  
  314. int volname(fd)                /* get the volume entry */
  315. struct fds *fd;                /* data storage area */
  316. {
  317.     struct {int ax,bx,cx,dx,si,di,ds,es;} reg;
  318.     char vnb[100];               /* volume name template buffer */
  319.  
  320.     segread(®.si);               /* set the segments */
  321.     bdos(0x1a,fd);               /* set the transfer address */
  322.     makefnam("\\*.*",srchname,vnb);    /* set proper drive in template */
  323.  
  324.     reg.dx = vnb;               /* point to volume template */
  325.     reg.cx = 0x08;               /* volume label wanted */
  326.     reg.ax = (0x4e << 8);           /* find first (only?) */
  327.     return !(sysint21(®,®)&1);   /* return true if it works */
  328. }
  329.  
  330. pdate(date)                   /* print a date */
  331. struct                       /* structure of date word */
  332. {   unsigned day : 5;               /* day */
  333.     unsigned month : 4;            /* month */
  334.     unsigned year : 7;               /* year since 1980 */
  335. }   date;                   /* date to print */
  336. {
  337.     static char *mname[] =           /* list of month names */
  338.     {     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  339.      "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  340.     };
  341.  
  342.     printf("%s %2d, %04d ",mname[date.month-1],date.day,date.year+1980);
  343. }
  344.  
  345. ptime(time)                   /* print a time */
  346. struct                       /* structure of time word */
  347. {   unsigned sec : 5;               /* second pair */
  348.     unsigned minute : 6;           /* minute */
  349.     unsigned hour : 5;               /* hour */
  350. }   time;                   /* time to print */
  351. {
  352.     int hh = time.hour;            /* fudged time */
  353.     char ap = hh<12 ? 'a' : 'p';       /* am/pm marker */
  354.  
  355.     if(hh>12)                   /* if afternoon */
  356.      hh -= 12;               /* then convert to civilian */
  357.     if(hh==0)                   /* if in the wee hours */
  358.      hh = 12;               /* then give as midnight */
  359.  
  360.     printf("%2d:%02d%c ",hh,time.minute,ap);
  361. }
  362.